﻿using System;

namespace HalconDotNet
{
	/// <summary>Class grouping methods belonging to no other HALCON class.</summary>
	// Token: 0x0200004C RID: 76
	public class HMisc
	{
		/// <summary>Write a tuple to a file.</summary>
		/// <param name="tuple">Tuple with any kind of data.</param>
		/// <param name="fileName">Name of the file to be written.</param>
		// Token: 0x06000A73 RID: 2675 RVA: 0x00042550 File Offset: 0x00040750
		public static void WriteTuple(HTuple tuple, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(219);
			HalconAPI.Store(proc, 0, tuple);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(tuple);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Read a tuple from a file.</summary>
		/// <param name="fileName">Name of the file to be read.</param>
		/// <returns>Tuple with any kind of data.</returns>
		// Token: 0x06000A74 RID: 2676 RVA: 0x0004258C File Offset: 0x0004078C
		public static HTuple ReadTuple(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(220);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>This operator is inoperable. It had the following function: Close all serial devices.</summary>
		// Token: 0x06000A75 RID: 2677 RVA: 0x000425CC File Offset: 0x000407CC
		public static void CloseAllSerials()
		{
			IntPtr proc = HalconAPI.PreCall(312);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>This operator is inoperable. It had the following function:  Clear all OCV tools.</summary>
		// Token: 0x06000A76 RID: 2678 RVA: 0x000425F0 File Offset: 0x000407F0
		public static void CloseAllOcvs()
		{
			IntPtr proc = HalconAPI.PreCall(644);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>This operator is inoperable. It had the following function: Destroy all OCR classifiers.</summary>
		// Token: 0x06000A77 RID: 2679 RVA: 0x00042614 File Offset: 0x00040814
		public static void CloseAllOcrs()
		{
			IntPtr proc = HalconAPI.PreCall(724);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Concat training files.</summary>
		/// <param name="singleFiles">Names of the single training files. Default: ""</param>
		/// <param name="composedFile">Name of the composed training file. Default: "all_characters"</param>
		// Token: 0x06000A78 RID: 2680 RVA: 0x00042638 File Offset: 0x00040838
		public static void ConcatOcrTrainf(HTuple singleFiles, string composedFile)
		{
			IntPtr proc = HalconAPI.PreCall(728);
			HalconAPI.Store(proc, 0, singleFiles);
			HalconAPI.StoreS(proc, 1, composedFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(singleFiles);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Concat training files.</summary>
		/// <param name="singleFiles">Names of the single training files. Default: ""</param>
		/// <param name="composedFile">Name of the composed training file. Default: "all_characters"</param>
		// Token: 0x06000A79 RID: 2681 RVA: 0x00042674 File Offset: 0x00040874
		public static void ConcatOcrTrainf(string singleFiles, string composedFile)
		{
			IntPtr proc = HalconAPI.PreCall(728);
			HalconAPI.StoreS(proc, 0, singleFiles);
			HalconAPI.StoreS(proc, 1, composedFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Query which characters are stored in a (protected) training file.</summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="characterCount">Number of characters.</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000A7A RID: 2682 RVA: 0x000426A8 File Offset: 0x000408A8
		public static HTuple ReadOcrTrainfNamesProtected(HTuple trainingFile, HTuple password, out HTuple characterCount)
		{
			IntPtr proc = HalconAPI.PreCall(731);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, password);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(password);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out characterCount);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Query which characters are stored in a (protected) training file.</summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="characterCount">Number of characters.</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000A7B RID: 2683 RVA: 0x00042710 File Offset: 0x00040910
		public static string ReadOcrTrainfNamesProtected(string trainingFile, string password, out int characterCount)
		{
			IntPtr proc = HalconAPI.PreCall(731);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, password);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out characterCount);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Query which characters are stored in a training file.</summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="characterCount">Number of characters.</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000A7C RID: 2684 RVA: 0x0004276C File Offset: 0x0004096C
		public static HTuple ReadOcrTrainfNames(HTuple trainingFile, out HTuple characterCount)
		{
			IntPtr proc = HalconAPI.PreCall(732);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out characterCount);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Query which characters are stored in a training file.</summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="characterCount">Number of characters.</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000A7D RID: 2685 RVA: 0x000427C8 File Offset: 0x000409C8
		public static string ReadOcrTrainfNames(string trainingFile, out int characterCount)
		{
			IntPtr proc = HalconAPI.PreCall(732);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out characterCount);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>This operator is inoperable. It had the following function:  Delete all measure objects.</summary>
		// Token: 0x06000A7E RID: 2686 RVA: 0x0004281C File Offset: 0x00040A1C
		public static void CloseAllMeasures()
		{
			IntPtr proc = HalconAPI.PreCall(826);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Convert spherical coordinates of a 3D point to Cartesian coordinates.</summary>
		/// <param name="longitude">Longitude of the 3D point.</param>
		/// <param name="latitude">Latitude of the 3D point.</param>
		/// <param name="radius">Radius of the 3D point.</param>
		/// <param name="equatPlaneNormal">Normal vector of the equatorial plane (points to the north pole). Default: "-y"</param>
		/// <param name="zeroMeridian">Coordinate axis in the equatorial plane that points to the zero meridian. Default: "-z"</param>
		/// <param name="x">X coordinate of the 3D point.</param>
		/// <param name="y">Y coordinate of the 3D point.</param>
		/// <param name="z">Z coordinate of the 3D point.</param>
		// Token: 0x06000A7F RID: 2687 RVA: 0x00042840 File Offset: 0x00040A40
		public static void ConvertPoint3dSpherToCart(HTuple longitude, HTuple latitude, HTuple radius, string equatPlaneNormal, string zeroMeridian, out HTuple x, out HTuple y, out HTuple z)
		{
			IntPtr proc = HalconAPI.PreCall(1046);
			HalconAPI.Store(proc, 0, longitude);
			HalconAPI.Store(proc, 1, latitude);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.StoreS(proc, 3, equatPlaneNormal);
			HalconAPI.StoreS(proc, 4, zeroMeridian);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(longitude);
			HalconAPI.UnpinTuple(latitude);
			HalconAPI.UnpinTuple(radius);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out z);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Convert spherical coordinates of a 3D point to Cartesian coordinates.</summary>
		/// <param name="longitude">Longitude of the 3D point.</param>
		/// <param name="latitude">Latitude of the 3D point.</param>
		/// <param name="radius">Radius of the 3D point.</param>
		/// <param name="equatPlaneNormal">Normal vector of the equatorial plane (points to the north pole). Default: "-y"</param>
		/// <param name="zeroMeridian">Coordinate axis in the equatorial plane that points to the zero meridian. Default: "-z"</param>
		/// <param name="x">X coordinate of the 3D point.</param>
		/// <param name="y">Y coordinate of the 3D point.</param>
		/// <param name="z">Z coordinate of the 3D point.</param>
		// Token: 0x06000A80 RID: 2688 RVA: 0x000428DC File Offset: 0x00040ADC
		public static void ConvertPoint3dSpherToCart(double longitude, double latitude, double radius, string equatPlaneNormal, string zeroMeridian, out double x, out double y, out double z)
		{
			IntPtr proc = HalconAPI.PreCall(1046);
			HalconAPI.StoreD(proc, 0, longitude);
			HalconAPI.StoreD(proc, 1, latitude);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.StoreS(proc, 3, equatPlaneNormal);
			HalconAPI.StoreS(proc, 4, zeroMeridian);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out x);
			num = HalconAPI.LoadD(proc, 1, num, out y);
			num = HalconAPI.LoadD(proc, 2, num, out z);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Convert Cartesian coordinates of a 3D point to spherical coordinates.</summary>
		/// <param name="x">X coordinate of the 3D point.</param>
		/// <param name="y">Y coordinate of the 3D point.</param>
		/// <param name="z">Z coordinate of the 3D point.</param>
		/// <param name="equatPlaneNormal">Normal vector of the equatorial plane (points to the north pole). Default: "-y"</param>
		/// <param name="zeroMeridian">Coordinate axis in the equatorial plane that points to the zero meridian. Default: "-z"</param>
		/// <param name="latitude">Latitude of the 3D point.</param>
		/// <param name="radius">Radius of the 3D point.</param>
		/// <returns>Longitude of the 3D point.</returns>
		// Token: 0x06000A81 RID: 2689 RVA: 0x00042964 File Offset: 0x00040B64
		public static HTuple ConvertPoint3dCartToSpher(HTuple x, HTuple y, HTuple z, string equatPlaneNormal, string zeroMeridian, out HTuple latitude, out HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1047);
			HalconAPI.Store(proc, 0, x);
			HalconAPI.Store(proc, 1, y);
			HalconAPI.Store(proc, 2, z);
			HalconAPI.StoreS(proc, 3, equatPlaneNormal);
			HalconAPI.StoreS(proc, 4, zeroMeridian);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(x);
			HalconAPI.UnpinTuple(y);
			HalconAPI.UnpinTuple(z);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out latitude);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out radius);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Convert Cartesian coordinates of a 3D point to spherical coordinates.</summary>
		/// <param name="x">X coordinate of the 3D point.</param>
		/// <param name="y">Y coordinate of the 3D point.</param>
		/// <param name="z">Z coordinate of the 3D point.</param>
		/// <param name="equatPlaneNormal">Normal vector of the equatorial plane (points to the north pole). Default: "-y"</param>
		/// <param name="zeroMeridian">Coordinate axis in the equatorial plane that points to the zero meridian. Default: "-z"</param>
		/// <param name="latitude">Latitude of the 3D point.</param>
		/// <param name="radius">Radius of the 3D point.</param>
		/// <returns>Longitude of the 3D point.</returns>
		// Token: 0x06000A82 RID: 2690 RVA: 0x00042A00 File Offset: 0x00040C00
		public static double ConvertPoint3dCartToSpher(double x, double y, double z, string equatPlaneNormal, string zeroMeridian, out double latitude, out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1047);
			HalconAPI.StoreD(proc, 0, x);
			HalconAPI.StoreD(proc, 1, y);
			HalconAPI.StoreD(proc, 2, z);
			HalconAPI.StoreS(proc, 3, equatPlaneNormal);
			HalconAPI.StoreS(proc, 4, zeroMeridian);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out latitude);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Read the description file of a Kalman filter.</summary>
		/// <param name="fileName">Description file for a Kalman filter. Default: "kalman.init"</param>
		/// <param name="model">The lined up matrices A, C, Q, possibly G and u, and if necessary L stored in row-major order.</param>
		/// <param name="measurement">The matrix R stored in row-major order.</param>
		/// <param name="prediction">The matrix P0@f$P_{0}$ (error covariance matrix of the initial state estimate) stored in row-major order and the initial state estimate x0@f$x_{0}$ lined up.</param>
		/// <returns>The dimensions of the state vector, the measurement vector and the controller vector.</returns>
		// Token: 0x06000A83 RID: 2691 RVA: 0x00042A88 File Offset: 0x00040C88
		public static HTuple ReadKalman(string fileName, out HTuple model, out HTuple measurement, out HTuple prediction)
		{
			IntPtr proc = HalconAPI.PreCall(1105);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out model);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out measurement);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out prediction);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Read an update file of a Kalman filter.</summary>
		/// <param name="fileName">Update file for a Kalman filter. Default: "kalman.updt"</param>
		/// <param name="dimensionIn">The dimensions of the state vector, measurement vector and controller vector. Default: [3,1,0]</param>
		/// <param name="modelIn">The lined up matrices A,C,Q, possibly G and u, and if necessary L which all have been stored in row-major order. Default: [1.0,1.0,0.5,0.0,1.0,1.0,0.0,0.0,1.0,1.0,0.0,0.0,54.3,37.9,48.0,37.9,34.3,42.5,48.0,42.5,43.7]</param>
		/// <param name="measurementIn">The matrix R stored in row-major order. Default: [1,2]</param>
		/// <param name="modelOut">The lined up matrices A,C,Q, possibly G and u, and if necessary L which all have been stored in row-major order.</param>
		/// <param name="measurementOut">The matrix R stored in row-major order.</param>
		/// <returns>The dimensions of the state vector, measurement vector and controller vector.</returns>
		// Token: 0x06000A84 RID: 2692 RVA: 0x00042B04 File Offset: 0x00040D04
		public static HTuple UpdateKalman(string fileName, HTuple dimensionIn, HTuple modelIn, HTuple measurementIn, out HTuple modelOut, out HTuple measurementOut)
		{
			IntPtr proc = HalconAPI.PreCall(1106);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.Store(proc, 1, dimensionIn);
			HalconAPI.Store(proc, 2, modelIn);
			HalconAPI.Store(proc, 3, measurementIn);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(dimensionIn);
			HalconAPI.UnpinTuple(modelIn);
			HalconAPI.UnpinTuple(measurementIn);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out modelOut);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out measurementOut);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Estimate the current state of a system with the help of the Kalman filtering.</summary>
		/// <param name="dimension">The dimensions of the state vector, the measurement and the controller vector. Default: [3,1,0]</param>
		/// <param name="model">The lined up matrices A,C,Q, possibly G and u, and if necessary L which have been stored in row-major order. Default: [1.0,1.0,0.5,0.0,1.0,1.0,0.0,0.0,1.0,1.0,0.0,0.0,54.3,37.9,48.0,37.9,34.3,42.5,48.0,42.5,43.7]</param>
		/// <param name="measurement">The matrix R stored in row-major order and the measurement vector y lined up. Default: [1.2,1.0]</param>
		/// <param name="predictionIn">The matrix P*@f$P$ (the extrapolation-error covariances) stored in row-major order and the extrapolation vector x*@f$x$ lined up. Default: [0.0,0.0,0.0,0.0,180.5,0.0,0.0,0.0,100.0,0.0,100.0,0.0]</param>
		/// <param name="estimate">The matrix P~@f$P$ (the estimation-error covariances) stored in row-major order and the estimated state x~@f$x$ lined up.</param>
		/// <returns>The matrix P* (the extrapolation-error covariances)stored in row-major order and the extrapolation vector x*@f$x$ lined up.</returns>
		// Token: 0x06000A85 RID: 2693 RVA: 0x00042B98 File Offset: 0x00040D98
		public static HTuple FilterKalman(HTuple dimension, HTuple model, HTuple measurement, HTuple predictionIn, out HTuple estimate)
		{
			IntPtr proc = HalconAPI.PreCall(1107);
			HalconAPI.Store(proc, 0, dimension);
			HalconAPI.Store(proc, 1, model);
			HalconAPI.Store(proc, 2, measurement);
			HalconAPI.Store(proc, 3, predictionIn);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(dimension);
			HalconAPI.UnpinTuple(model);
			HalconAPI.UnpinTuple(measurement);
			HalconAPI.UnpinTuple(predictionIn);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out estimate);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Generate a PostScript file, which describes the rectification grid.</summary>
		/// <param name="width">Width of the checkered pattern in meters (without the two frames). Default: 0.17</param>
		/// <param name="numSquares">Number of squares per row and column. Default: 17</param>
		/// <param name="gridFile">File name of the PostScript file. Default: "rectification_grid.ps"</param>
		// Token: 0x06000A86 RID: 2694 RVA: 0x00042C20 File Offset: 0x00040E20
		public static void CreateRectificationGrid(double width, int numSquares, string gridFile)
		{
			IntPtr proc = HalconAPI.PreCall(1157);
			HalconAPI.StoreD(proc, 0, width);
			HalconAPI.StoreI(proc, 1, numSquares);
			HalconAPI.StoreS(proc, 2, gridFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Generate a projection map that describes the mapping between an arbitrarily distorted image and the rectified image.</summary>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="row">Row coordinates of the grid points in the distorted image.</param>
		/// <param name="column">Column coordinates of the grid points in the distorted image.</param>
		/// <param name="gridWidth">Width of the point grid (number of grid points).</param>
		/// <param name="imageWidth">Width of the images to be rectified.</param>
		/// <param name="imageHeight">Height of the images to be rectified.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06000A87 RID: 2695 RVA: 0x00042C5C File Offset: 0x00040E5C
		public static HImage GenArbitraryDistortionMap(int gridSpacing, HTuple row, HTuple column, int gridWidth, int imageWidth, int imageHeight, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1160);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.StoreI(proc, 3, gridWidth);
			HalconAPI.StoreI(proc, 4, imageWidth);
			HalconAPI.StoreI(proc, 5, imageHeight);
			HalconAPI.StoreS(proc, 6, mapType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the projection of a point onto a line.</summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column coordinate of the point.</param>
		/// <param name="row1">Row coordinate of the first point on the line.</param>
		/// <param name="column1">Column coordinate of the first point on the line.</param>
		/// <param name="row2">Row coordinate of the second point on the line.</param>
		/// <param name="column2">Column coordinate of the second point on the line.</param>
		/// <param name="rowProj">Row coordinate of the projected point.</param>
		/// <param name="colProj">Column coordinate of the projected point</param>
		// Token: 0x06000A88 RID: 2696 RVA: 0x00042CDC File Offset: 0x00040EDC
		public static void ProjectionPl(HTuple row, HTuple column, HTuple row1, HTuple column1, HTuple row2, HTuple column2, out HTuple rowProj, out HTuple colProj)
		{
			IntPtr proc = HalconAPI.PreCall(1338);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, row1);
			HalconAPI.Store(proc, 3, column1);
			HalconAPI.Store(proc, 4, row2);
			HalconAPI.Store(proc, 5, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowProj);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out colProj);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the projection of a point onto a line.</summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column coordinate of the point.</param>
		/// <param name="row1">Row coordinate of the first point on the line.</param>
		/// <param name="column1">Column coordinate of the first point on the line.</param>
		/// <param name="row2">Row coordinate of the second point on the line.</param>
		/// <param name="column2">Column coordinate of the second point on the line.</param>
		/// <param name="rowProj">Row coordinate of the projected point.</param>
		/// <param name="colProj">Column coordinate of the projected point</param>
		// Token: 0x06000A89 RID: 2697 RVA: 0x00042D80 File Offset: 0x00040F80
		public static void ProjectionPl(double row, double column, double row1, double column1, double row2, double column2, out double rowProj, out double colProj)
		{
			IntPtr proc = HalconAPI.PreCall(1338);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, row1);
			HalconAPI.StoreD(proc, 3, column1);
			HalconAPI.StoreD(proc, 4, row2);
			HalconAPI.StoreD(proc, 5, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out rowProj);
			num = HalconAPI.LoadD(proc, 1, num, out colProj);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate points on the perimeter of an ellipse.</summary>
		/// <param name="angle">Angle corresponding to the resulting point [rad]. Default: 0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="rowPoint">Row coordinate of the point on the ellipse.</param>
		/// <param name="colPoint">Column coordinates of the point on the ellipse.</param>
		// Token: 0x06000A8A RID: 2698 RVA: 0x00042DFC File Offset: 0x00040FFC
		public static void GetPointsEllipse(HTuple angle, double row, double column, double phi, double radius1, double radius2, out HTuple rowPoint, out HTuple colPoint)
		{
			IntPtr proc = HalconAPI.PreCall(1339);
			HalconAPI.Store(proc, 0, angle);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, radius1);
			HalconAPI.StoreD(proc, 5, radius2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angle);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowPoint);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out colPoint);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate points on the perimeter of an ellipse.</summary>
		/// <param name="angle">Angle corresponding to the resulting point [rad]. Default: 0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="rowPoint">Row coordinate of the point on the ellipse.</param>
		/// <param name="colPoint">Column coordinates of the point on the ellipse.</param>
		// Token: 0x06000A8B RID: 2699 RVA: 0x00042E80 File Offset: 0x00041080
		public static void GetPointsEllipse(double angle, double row, double column, double phi, double radius1, double radius2, out double rowPoint, out double colPoint)
		{
			IntPtr proc = HalconAPI.PreCall(1339);
			HalconAPI.StoreD(proc, 0, angle);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, radius1);
			HalconAPI.StoreD(proc, 5, radius2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out rowPoint);
			num = HalconAPI.LoadD(proc, 1, num, out colPoint);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the intersection point of two lines.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the first line.</param>
		/// <param name="columnA1">Column coordinate of the first point of the first line.</param>
		/// <param name="rowA2">Row coordinate of the second point of the first line.</param>
		/// <param name="columnA2">Column coordinate of the second point of the first line.</param>
		/// <param name="rowB1">Row coordinate of the first point of the second line.</param>
		/// <param name="columnB1">Column coordinate of the first point of the second line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the second line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the second line.</param>
		/// <param name="row">Row coordinate of the intersection point.</param>
		/// <param name="column">Column coordinate of the intersection point.</param>
		/// <param name="isParallel">Are the two lines parallel?</param>
		// Token: 0x06000A8C RID: 2700 RVA: 0x00042EFC File Offset: 0x000410FC
		public static void IntersectionLl(HTuple rowA1, HTuple columnA1, HTuple rowA2, HTuple columnA2, HTuple rowB1, HTuple columnB1, HTuple rowB2, HTuple columnB2, out HTuple row, out HTuple column, out HTuple isParallel)
		{
			IntPtr proc = HalconAPI.PreCall(1340);
			HalconAPI.Store(proc, 0, rowA1);
			HalconAPI.Store(proc, 1, columnA1);
			HalconAPI.Store(proc, 2, rowA2);
			HalconAPI.Store(proc, 3, columnA2);
			HalconAPI.Store(proc, 4, rowB1);
			HalconAPI.Store(proc, 5, columnB1);
			HalconAPI.Store(proc, 6, rowB2);
			HalconAPI.Store(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowA1);
			HalconAPI.UnpinTuple(columnA1);
			HalconAPI.UnpinTuple(rowA2);
			HalconAPI.UnpinTuple(columnA2);
			HalconAPI.UnpinTuple(rowB1);
			HalconAPI.UnpinTuple(columnB1);
			HalconAPI.UnpinTuple(rowB2);
			HalconAPI.UnpinTuple(columnB2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out isParallel);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the intersection point of two lines.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the first line.</param>
		/// <param name="columnA1">Column coordinate of the first point of the first line.</param>
		/// <param name="rowA2">Row coordinate of the second point of the first line.</param>
		/// <param name="columnA2">Column coordinate of the second point of the first line.</param>
		/// <param name="rowB1">Row coordinate of the first point of the second line.</param>
		/// <param name="columnB1">Column coordinate of the first point of the second line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the second line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the second line.</param>
		/// <param name="row">Row coordinate of the intersection point.</param>
		/// <param name="column">Column coordinate of the intersection point.</param>
		/// <param name="isParallel">Are the two lines parallel?</param>
		// Token: 0x06000A8D RID: 2701 RVA: 0x00042FD4 File Offset: 0x000411D4
		public static void IntersectionLl(double rowA1, double columnA1, double rowA2, double columnA2, double rowB1, double columnB1, double rowB2, double columnB2, out double row, out double column, out int isParallel)
		{
			IntPtr proc = HalconAPI.PreCall(1340);
			HalconAPI.StoreD(proc, 0, rowA1);
			HalconAPI.StoreD(proc, 1, columnA1);
			HalconAPI.StoreD(proc, 2, rowA2);
			HalconAPI.StoreD(proc, 3, columnA2);
			HalconAPI.StoreD(proc, 4, rowB1);
			HalconAPI.StoreD(proc, 5, columnB1);
			HalconAPI.StoreD(proc, 6, rowB2);
			HalconAPI.StoreD(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadI(proc, 2, num, out isParallel);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the angle between one line and the horizontal axis.</summary>
		/// <param name="row1">Row coordinate the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <returns>Angle between the line and the horizontal axis [rad].</returns>
		// Token: 0x06000A8E RID: 2702 RVA: 0x00043078 File Offset: 0x00041278
		public static HTuple AngleLx(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1370);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the angle between one line and the horizontal axis.</summary>
		/// <param name="row1">Row coordinate the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <returns>Angle between the line and the horizontal axis [rad].</returns>
		// Token: 0x06000A8F RID: 2703 RVA: 0x000430EC File Offset: 0x000412EC
		public static double AngleLx(double row1, double column1, double row2, double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1370);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the angle between two lines.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the first line.</param>
		/// <param name="columnA1">Column coordinate of the first point of the first line.</param>
		/// <param name="rowA2">Row coordinate of the second point of the first line.</param>
		/// <param name="columnA2">Column coordinate of the second point of the first line.</param>
		/// <param name="rowB1">Row coordinate of the first point of the second line.</param>
		/// <param name="columnB1">Column coordinate of the first point of the second line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the second line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the second line.</param>
		/// <returns>Angle between the lines [rad].</returns>
		// Token: 0x06000A90 RID: 2704 RVA: 0x00043144 File Offset: 0x00041344
		public static HTuple AngleLl(HTuple rowA1, HTuple columnA1, HTuple rowA2, HTuple columnA2, HTuple rowB1, HTuple columnB1, HTuple rowB2, HTuple columnB2)
		{
			IntPtr proc = HalconAPI.PreCall(1371);
			HalconAPI.Store(proc, 0, rowA1);
			HalconAPI.Store(proc, 1, columnA1);
			HalconAPI.Store(proc, 2, rowA2);
			HalconAPI.Store(proc, 3, columnA2);
			HalconAPI.Store(proc, 4, rowB1);
			HalconAPI.Store(proc, 5, columnB1);
			HalconAPI.Store(proc, 6, rowB2);
			HalconAPI.Store(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowA1);
			HalconAPI.UnpinTuple(columnA1);
			HalconAPI.UnpinTuple(rowA2);
			HalconAPI.UnpinTuple(columnA2);
			HalconAPI.UnpinTuple(rowB1);
			HalconAPI.UnpinTuple(columnB1);
			HalconAPI.UnpinTuple(rowB2);
			HalconAPI.UnpinTuple(columnB2);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the angle between two lines.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the first line.</param>
		/// <param name="columnA1">Column coordinate of the first point of the first line.</param>
		/// <param name="rowA2">Row coordinate of the second point of the first line.</param>
		/// <param name="columnA2">Column coordinate of the second point of the first line.</param>
		/// <param name="rowB1">Row coordinate of the first point of the second line.</param>
		/// <param name="columnB1">Column coordinate of the first point of the second line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the second line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the second line.</param>
		/// <returns>Angle between the lines [rad].</returns>
		// Token: 0x06000A91 RID: 2705 RVA: 0x000431F8 File Offset: 0x000413F8
		public static double AngleLl(double rowA1, double columnA1, double rowA2, double columnA2, double rowB1, double columnB1, double rowB2, double columnB2)
		{
			IntPtr proc = HalconAPI.PreCall(1371);
			HalconAPI.StoreD(proc, 0, rowA1);
			HalconAPI.StoreD(proc, 1, columnA1);
			HalconAPI.StoreD(proc, 2, rowA2);
			HalconAPI.StoreD(proc, 3, columnA2);
			HalconAPI.StoreD(proc, 4, rowB1);
			HalconAPI.StoreD(proc, 5, columnB1);
			HalconAPI.StoreD(proc, 6, rowB2);
			HalconAPI.StoreD(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the distances between a line segment and a line.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the line segment.</param>
		/// <param name="columnA1">Column coordinate of the first point of the line segment.</param>
		/// <param name="rowA2">Row coordinate of the second point of the line segment.</param>
		/// <param name="columnA2">Column coordinate of the second point of the line segment.</param>
		/// <param name="rowB1">Row coordinate of the first point of the line.</param>
		/// <param name="columnB1">Column coordinate of the first point of the line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line segment and the line.</param>
		/// <param name="distanceMax">Maximum distance between the line segment and the line.</param>
		// Token: 0x06000A92 RID: 2706 RVA: 0x00043274 File Offset: 0x00041474
		public static void DistanceSl(HTuple rowA1, HTuple columnA1, HTuple rowA2, HTuple columnA2, HTuple rowB1, HTuple columnB1, HTuple rowB2, HTuple columnB2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1372);
			HalconAPI.Store(proc, 0, rowA1);
			HalconAPI.Store(proc, 1, columnA1);
			HalconAPI.Store(proc, 2, rowA2);
			HalconAPI.Store(proc, 3, columnA2);
			HalconAPI.Store(proc, 4, rowB1);
			HalconAPI.Store(proc, 5, columnB1);
			HalconAPI.Store(proc, 6, rowB2);
			HalconAPI.Store(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowA1);
			HalconAPI.UnpinTuple(columnA1);
			HalconAPI.UnpinTuple(rowA2);
			HalconAPI.UnpinTuple(columnA2);
			HalconAPI.UnpinTuple(rowB1);
			HalconAPI.UnpinTuple(columnB1);
			HalconAPI.UnpinTuple(rowB2);
			HalconAPI.UnpinTuple(columnB2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the distances between a line segment and a line.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the line segment.</param>
		/// <param name="columnA1">Column coordinate of the first point of the line segment.</param>
		/// <param name="rowA2">Row coordinate of the second point of the line segment.</param>
		/// <param name="columnA2">Column coordinate of the second point of the line segment.</param>
		/// <param name="rowB1">Row coordinate of the first point of the line.</param>
		/// <param name="columnB1">Column coordinate of the first point of the line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line segment and the line.</param>
		/// <param name="distanceMax">Maximum distance between the line segment and the line.</param>
		// Token: 0x06000A93 RID: 2707 RVA: 0x00043338 File Offset: 0x00041538
		public static void DistanceSl(double rowA1, double columnA1, double rowA2, double columnA2, double rowB1, double columnB1, double rowB2, double columnB2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1372);
			HalconAPI.StoreD(proc, 0, rowA1);
			HalconAPI.StoreD(proc, 1, columnA1);
			HalconAPI.StoreD(proc, 2, rowA2);
			HalconAPI.StoreD(proc, 3, columnA2);
			HalconAPI.StoreD(proc, 4, rowB1);
			HalconAPI.StoreD(proc, 5, columnB1);
			HalconAPI.StoreD(proc, 6, rowB2);
			HalconAPI.StoreD(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the distances between two line segments.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the line segment.</param>
		/// <param name="columnA1">Column coordinate of the first point of the line segment.</param>
		/// <param name="rowA2">Row coordinate of the second point of the line segment.</param>
		/// <param name="columnA2">Column coordinate of the second point of the line segment.</param>
		/// <param name="rowB1">Row coordinate of the first point of the line.</param>
		/// <param name="columnB1">Column of the first point of the line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line segments.</param>
		/// <param name="distanceMax">Maximum distance between the line segments.</param>
		// Token: 0x06000A94 RID: 2708 RVA: 0x000433C8 File Offset: 0x000415C8
		public static void DistanceSs(HTuple rowA1, HTuple columnA1, HTuple rowA2, HTuple columnA2, HTuple rowB1, HTuple columnB1, HTuple rowB2, HTuple columnB2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1373);
			HalconAPI.Store(proc, 0, rowA1);
			HalconAPI.Store(proc, 1, columnA1);
			HalconAPI.Store(proc, 2, rowA2);
			HalconAPI.Store(proc, 3, columnA2);
			HalconAPI.Store(proc, 4, rowB1);
			HalconAPI.Store(proc, 5, columnB1);
			HalconAPI.Store(proc, 6, rowB2);
			HalconAPI.Store(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowA1);
			HalconAPI.UnpinTuple(columnA1);
			HalconAPI.UnpinTuple(rowA2);
			HalconAPI.UnpinTuple(columnA2);
			HalconAPI.UnpinTuple(rowB1);
			HalconAPI.UnpinTuple(columnB1);
			HalconAPI.UnpinTuple(rowB2);
			HalconAPI.UnpinTuple(columnB2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the distances between two line segments.</summary>
		/// <param name="rowA1">Row coordinate of the first point of the line segment.</param>
		/// <param name="columnA1">Column coordinate of the first point of the line segment.</param>
		/// <param name="rowA2">Row coordinate of the second point of the line segment.</param>
		/// <param name="columnA2">Column coordinate of the second point of the line segment.</param>
		/// <param name="rowB1">Row coordinate of the first point of the line.</param>
		/// <param name="columnB1">Column of the first point of the line.</param>
		/// <param name="rowB2">Row coordinate of the second point of the line.</param>
		/// <param name="columnB2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line segments.</param>
		/// <param name="distanceMax">Maximum distance between the line segments.</param>
		// Token: 0x06000A95 RID: 2709 RVA: 0x0004348C File Offset: 0x0004168C
		public static void DistanceSs(double rowA1, double columnA1, double rowA2, double columnA2, double rowB1, double columnB1, double rowB2, double columnB2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1373);
			HalconAPI.StoreD(proc, 0, rowA1);
			HalconAPI.StoreD(proc, 1, columnA1);
			HalconAPI.StoreD(proc, 2, rowA2);
			HalconAPI.StoreD(proc, 3, columnA2);
			HalconAPI.StoreD(proc, 4, rowB1);
			HalconAPI.StoreD(proc, 5, columnB1);
			HalconAPI.StoreD(proc, 6, rowB2);
			HalconAPI.StoreD(proc, 7, columnB2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the distances between a point and a line segment.</summary>
		/// <param name="row">Row coordinate of the first point.</param>
		/// <param name="column">Column coordinate of the first point.</param>
		/// <param name="row1">Row coordinate of the first point of the line segment.</param>
		/// <param name="column1">Column coordinate of the first point of the line segment.</param>
		/// <param name="row2">Row coordinate of the second point of the line segment.</param>
		/// <param name="column2">Column coordinate of the second point of the line segment.</param>
		/// <param name="distanceMin">Minimum distance between the point and the line segment.</param>
		/// <param name="distanceMax">Maximum distance between the point and the line segment.</param>
		// Token: 0x06000A96 RID: 2710 RVA: 0x0004351C File Offset: 0x0004171C
		public static void DistancePs(HTuple row, HTuple column, HTuple row1, HTuple column1, HTuple row2, HTuple column2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1374);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, row1);
			HalconAPI.Store(proc, 3, column1);
			HalconAPI.Store(proc, 4, row2);
			HalconAPI.Store(proc, 5, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the distances between a point and a line segment.</summary>
		/// <param name="row">Row coordinate of the first point.</param>
		/// <param name="column">Column coordinate of the first point.</param>
		/// <param name="row1">Row coordinate of the first point of the line segment.</param>
		/// <param name="column1">Column coordinate of the first point of the line segment.</param>
		/// <param name="row2">Row coordinate of the second point of the line segment.</param>
		/// <param name="column2">Column coordinate of the second point of the line segment.</param>
		/// <param name="distanceMin">Minimum distance between the point and the line segment.</param>
		/// <param name="distanceMax">Maximum distance between the point and the line segment.</param>
		// Token: 0x06000A97 RID: 2711 RVA: 0x000435C0 File Offset: 0x000417C0
		public static void DistancePs(double row, double column, double row1, double column1, double row2, double column2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1374);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, row1);
			HalconAPI.StoreD(proc, 3, column1);
			HalconAPI.StoreD(proc, 4, row2);
			HalconAPI.StoreD(proc, 5, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the distance between one point and one line.</summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column of the point.</param>
		/// <param name="row1">Row coordinate of the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <returns>Distance between the points.</returns>
		// Token: 0x06000A98 RID: 2712 RVA: 0x0004363C File Offset: 0x0004183C
		public static HTuple DistancePl(HTuple row, HTuple column, HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1375);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, row1);
			HalconAPI.Store(proc, 3, column1);
			HalconAPI.Store(proc, 4, row2);
			HalconAPI.Store(proc, 5, column2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the distance between one point and one line.</summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column of the point.</param>
		/// <param name="row1">Row coordinate of the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <returns>Distance between the points.</returns>
		// Token: 0x06000A99 RID: 2713 RVA: 0x000436D0 File Offset: 0x000418D0
		public static double DistancePl(double row, double column, double row1, double column1, double row2, double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1375);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, row1);
			HalconAPI.StoreD(proc, 3, column1);
			HalconAPI.StoreD(proc, 4, row2);
			HalconAPI.StoreD(proc, 5, column2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the distance between two points.</summary>
		/// <param name="row1">Row coordinate of the first point.</param>
		/// <param name="column1">Column coordinate of the first point.</param>
		/// <param name="row2">Row coordinate of the second point.</param>
		/// <param name="column2">Column coordinate of the second point.</param>
		/// <returns>Distance between the points.</returns>
		// Token: 0x06000A9A RID: 2714 RVA: 0x0004373C File Offset: 0x0004193C
		public static HTuple DistancePp(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1376);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the distance between two points.</summary>
		/// <param name="row1">Row coordinate of the first point.</param>
		/// <param name="column1">Column coordinate of the first point.</param>
		/// <param name="row2">Row coordinate of the second point.</param>
		/// <param name="column2">Column coordinate of the second point.</param>
		/// <returns>Distance between the points.</returns>
		// Token: 0x06000A9B RID: 2715 RVA: 0x000437B0 File Offset: 0x000419B0
		public static double DistancePp(double row1, double column1, double row2, double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1376);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Information on smoothing filter smooth_image.</summary>
		/// <param name="filter">Name of required filter. Default: "deriche2"</param>
		/// <param name="alpha">Filter parameter: small values effect strong smoothing (reversed in case of 'gauss'). Default: 0.5</param>
		/// <param name="coeffs">In case of gauss filter: coefficients of the "positive" half of the 1D impulse answer.</param>
		/// <returns>Width of filter is approx. size x size pixels.</returns>
		// Token: 0x06000A9C RID: 2716 RVA: 0x00043808 File Offset: 0x00041A08
		public static int InfoSmooth(string filter, double alpha, out HTuple coeffs)
		{
			IntPtr proc = HalconAPI.PreCall(1419);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out coeffs);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Generate a Gaussian noise distribution.</summary>
		/// <param name="sigma">Standard deviation of the Gaussian noise distribution. Default: 2.0</param>
		/// <returns>Resulting Gaussian noise distribution.</returns>
		// Token: 0x06000A9D RID: 2717 RVA: 0x00043864 File Offset: 0x00041A64
		public static HTuple GaussDistribution(double sigma)
		{
			IntPtr proc = HalconAPI.PreCall(1443);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Generate a salt-and-pepper noise distribution.</summary>
		/// <param name="percentSalt">Percentage of salt (white noise pixels). Default: 5.0</param>
		/// <param name="percentPepper">Percentage of pepper (black noise pixels). Default: 5.0</param>
		/// <returns>Resulting noise distribution.</returns>
		// Token: 0x06000A9E RID: 2718 RVA: 0x000438A8 File Offset: 0x00041AA8
		public static HTuple SpDistribution(HTuple percentSalt, HTuple percentPepper)
		{
			IntPtr proc = HalconAPI.PreCall(1444);
			HalconAPI.Store(proc, 0, percentSalt);
			HalconAPI.Store(proc, 1, percentPepper);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(percentSalt);
			HalconAPI.UnpinTuple(percentPepper);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Generate a salt-and-pepper noise distribution.</summary>
		/// <param name="percentSalt">Percentage of salt (white noise pixels). Default: 5.0</param>
		/// <param name="percentPepper">Percentage of pepper (black noise pixels). Default: 5.0</param>
		/// <returns>Resulting noise distribution.</returns>
		// Token: 0x06000A9F RID: 2719 RVA: 0x00043900 File Offset: 0x00041B00
		public static HTuple SpDistribution(double percentSalt, double percentPepper)
		{
			IntPtr proc = HalconAPI.PreCall(1444);
			HalconAPI.StoreD(proc, 0, percentSalt);
			HalconAPI.StoreD(proc, 1, percentPepper);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Deserialize FFT speed optimization data.</summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06000AA0 RID: 2720 RVA: 0x0004394C File Offset: 0x00041B4C
		public static void DeserializeFftOptimizationData(HSerializedItem serializedItemHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1535);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>Serialize FFT speed optimization data.</summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06000AA1 RID: 2721 RVA: 0x00043980 File Offset: 0x00041B80
		public static HSerializedItem SerializeFftOptimizationData()
		{
			IntPtr proc = HalconAPI.PreCall(1536);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Load FFT speed optimization data from a file.</summary>
		/// <param name="fileName">File name of the optimization data. Default: "fft_opt.dat"</param>
		// Token: 0x06000AA2 RID: 2722 RVA: 0x000439B8 File Offset: 0x00041BB8
		public static void ReadFftOptimizationData(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1537);
			HalconAPI.StoreS(proc, 0, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Store FFT speed optimization data in a file.</summary>
		/// <param name="fileName">File name of the optimization data. Default: "fft_opt.dat"</param>
		// Token: 0x06000AA3 RID: 2723 RVA: 0x000439E4 File Offset: 0x00041BE4
		public static void WriteFftOptimizationData(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1538);
			HalconAPI.StoreS(proc, 0, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Optimize the runtime of the real-valued FFT.</summary>
		/// <param name="width">Width of the image for which the runtime should be optimized. Default: 512</param>
		/// <param name="height">Height of the image for which the runtime should be optimized. Default: 512</param>
		/// <param name="mode">Thoroughness of the search for the optimum runtime. Default: "standard"</param>
		// Token: 0x06000AA4 RID: 2724 RVA: 0x00043A10 File Offset: 0x00041C10
		public static void OptimizeRftSpeed(int width, int height, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1539);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.StoreS(proc, 2, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Optimize the runtime of the FFT.</summary>
		/// <param name="width">Width of the image for which the runtime should be optimized. Default: 512</param>
		/// <param name="height">Height of the image for which the runtime should be optimized. Default: 512</param>
		/// <param name="mode">Thoroughness of the search for the optimum runtime. Default: "standard"</param>
		// Token: 0x06000AA5 RID: 2725 RVA: 0x00043A4C File Offset: 0x00041C4C
		public static void OptimizeFftSpeed(int width, int height, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1540);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.StoreS(proc, 2, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Return the filter coefficients of a filter in edges_image.</summary>
		/// <param name="filter">Name of the edge operator. Default: "lanser2"</param>
		/// <param name="mode">1D edge filter ('edge') or 1D smoothing filter ('smooth'). Default: "edge"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 0.5</param>
		/// <param name="coeffs">For Canny filters: Coefficients of the "positive" half of the 1D impulse response. All others: Coefficients of a corresponding non-recursive  filter.</param>
		/// <returns>Filter width in pixels.</returns>
		// Token: 0x06000AA6 RID: 2726 RVA: 0x00043A88 File Offset: 0x00041C88
		public static int InfoEdges(string filter, string mode, double alpha, out HTuple coeffs)
		{
			IntPtr proc = HalconAPI.PreCall(1565);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.StoreD(proc, 2, alpha);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out coeffs);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Copy a file to a new location.</summary>
		/// <param name="sourceFile">File to be copied.</param>
		/// <param name="destinationFile">Target location.</param>
		// Token: 0x06000AA7 RID: 2727 RVA: 0x00043AEC File Offset: 0x00041CEC
		public static void CopyFile(string sourceFile, string destinationFile)
		{
			IntPtr proc = HalconAPI.PreCall(1638);
			HalconAPI.StoreS(proc, 0, sourceFile);
			HalconAPI.StoreS(proc, 1, destinationFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Set the current working directory.</summary>
		/// <param name="dirName">Name of current working directory to be set.</param>
		// Token: 0x06000AA8 RID: 2728 RVA: 0x00043B20 File Offset: 0x00041D20
		public static void SetCurrentDir(string dirName)
		{
			IntPtr proc = HalconAPI.PreCall(1639);
			HalconAPI.StoreS(proc, 0, dirName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Get the current working directory.</summary>
		/// <returns>Name of current working directory.</returns>
		// Token: 0x06000AA9 RID: 2729 RVA: 0x00043B4C File Offset: 0x00041D4C
		public static string GetCurrentDir()
		{
			IntPtr proc = HalconAPI.PreCall(1640);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Delete an empty directory.</summary>
		/// <param name="dirName">Name of directory to be deleted.</param>
		// Token: 0x06000AAA RID: 2730 RVA: 0x00043B84 File Offset: 0x00041D84
		public static void RemoveDir(string dirName)
		{
			IntPtr proc = HalconAPI.PreCall(1641);
			HalconAPI.StoreS(proc, 0, dirName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Make a directory.</summary>
		/// <param name="dirName">Name of directory to be created.</param>
		// Token: 0x06000AAB RID: 2731 RVA: 0x00043BB0 File Offset: 0x00041DB0
		public static void MakeDir(string dirName)
		{
			IntPtr proc = HalconAPI.PreCall(1642);
			HalconAPI.StoreS(proc, 0, dirName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>List all files in a directory.</summary>
		/// <param name="directory">Name of directory to be listed.</param>
		/// <param name="options">Processing options. Default: "files"</param>
		/// <returns>Found files (and directories).</returns>
		// Token: 0x06000AAC RID: 2732 RVA: 0x00043BDC File Offset: 0x00041DDC
		public static HTuple ListFiles(string directory, HTuple options)
		{
			IntPtr proc = HalconAPI.PreCall(1643);
			HalconAPI.StoreS(proc, 0, directory);
			HalconAPI.Store(proc, 1, options);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(options);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>List all files in a directory.</summary>
		/// <param name="directory">Name of directory to be listed.</param>
		/// <param name="options">Processing options. Default: "files"</param>
		/// <returns>Found files (and directories).</returns>
		// Token: 0x06000AAD RID: 2733 RVA: 0x00043C2C File Offset: 0x00041E2C
		public static HTuple ListFiles(string directory, string options)
		{
			IntPtr proc = HalconAPI.PreCall(1643);
			HalconAPI.StoreS(proc, 0, directory);
			HalconAPI.StoreS(proc, 1, options);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Delete a file.</summary>
		/// <param name="fileName">File to be deleted.</param>
		// Token: 0x06000AAE RID: 2734 RVA: 0x00043C74 File Offset: 0x00041E74
		public static void DeleteFile(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1644);
			HalconAPI.StoreS(proc, 0, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Check whether file exists.</summary>
		/// <param name="fileName">Name of file to be checked. Default: "/bin/cc"</param>
		/// <returns>boolean number.</returns>
		// Token: 0x06000AAF RID: 2735 RVA: 0x00043CA0 File Offset: 0x00041EA0
		public static int FileExists(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1645);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>This operator is inoperable. It had the following function: Close all open files.</summary>
		// Token: 0x06000AB0 RID: 2736 RVA: 0x00043CE0 File Offset: 0x00041EE0
		public static void CloseAllFiles()
		{
			IntPtr proc = HalconAPI.PreCall(1666);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Select the longest input lines.</summary>
		/// <param name="rowBeginIn">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBeginIn">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEndIn">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEndIn">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="num">(Maximum) desired number of output lines. Default: 10</param>
		/// <param name="rowBeginOut">Row coordinates of the starting points of the output lines.</param>
		/// <param name="colBeginOut">Column coordinates of the starting points of the output lines.</param>
		/// <param name="rowEndOut">Row coordinates of the ending points of the output lines.</param>
		/// <param name="colEndOut">Column coordinates of the ending points of the output lines.</param>
		// Token: 0x06000AB1 RID: 2737 RVA: 0x00043D04 File Offset: 0x00041F04
		public static void SelectLinesLongest(HTuple rowBeginIn, HTuple colBeginIn, HTuple rowEndIn, HTuple colEndIn, int num, out HTuple rowBeginOut, out HTuple colBeginOut, out HTuple rowEndOut, out HTuple colEndOut)
		{
			IntPtr proc = HalconAPI.PreCall(1736);
			HalconAPI.Store(proc, 0, rowBeginIn);
			HalconAPI.Store(proc, 1, colBeginIn);
			HalconAPI.Store(proc, 2, rowEndIn);
			HalconAPI.Store(proc, 3, colEndIn);
			HalconAPI.StoreI(proc, 4, num);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBeginIn);
			HalconAPI.UnpinTuple(colBeginIn);
			HalconAPI.UnpinTuple(rowEndIn);
			HalconAPI.UnpinTuple(colEndIn);
			num2 = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num2, out rowBeginOut);
			num2 = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num2, out colBeginOut);
			num2 = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num2, out rowEndOut);
			num2 = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num2, out colEndOut);
			HalconAPI.PostCall(proc, num2);
		}

		/// <summary>Partition lines according to various criteria.</summary>
		/// <param name="rowBeginIn">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBeginIn">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEndIn">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEndIn">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="feature">Features to be used for selection.</param>
		/// <param name="operation">Desired combination of the features.</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: "min"</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: "max"</param>
		/// <param name="rowBeginOut">Row coordinates of the starting points of the lines fulfilling the conditions.</param>
		/// <param name="colBeginOut">Column coordinates of the starting points of the lines fulfilling the conditions.</param>
		/// <param name="rowEndOut">Row coordinates of the ending points of the lines fulfilling the conditions.</param>
		/// <param name="colEndOut">Column coordinates of the ending points of the lines fulfilling the conditions.</param>
		/// <param name="failRowBOut">Row coordinates of the starting points of the lines not fulfilling the conditions.</param>
		/// <param name="failColBOut">Column coordinates of the starting points of the lines not fulfilling the conditions.</param>
		/// <param name="failRowEOut">Row coordinates of the ending points of the lines not fulfilling the conditions.</param>
		/// <param name="failColEOut">Column coordinates of the ending points of the lines not fulfilling the conditions.</param>
		// Token: 0x06000AB2 RID: 2738 RVA: 0x00043DBC File Offset: 0x00041FBC
		public static void PartitionLines(HTuple rowBeginIn, HTuple colBeginIn, HTuple rowEndIn, HTuple colEndIn, HTuple feature, string operation, HTuple min, HTuple max, out HTuple rowBeginOut, out HTuple colBeginOut, out HTuple rowEndOut, out HTuple colEndOut, out HTuple failRowBOut, out HTuple failColBOut, out HTuple failRowEOut, out HTuple failColEOut)
		{
			IntPtr proc = HalconAPI.PreCall(1737);
			HalconAPI.Store(proc, 0, rowBeginIn);
			HalconAPI.Store(proc, 1, colBeginIn);
			HalconAPI.Store(proc, 2, rowEndIn);
			HalconAPI.Store(proc, 3, colEndIn);
			HalconAPI.Store(proc, 4, feature);
			HalconAPI.StoreS(proc, 5, operation);
			HalconAPI.Store(proc, 6, min);
			HalconAPI.Store(proc, 7, max);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBeginIn);
			HalconAPI.UnpinTuple(colBeginIn);
			HalconAPI.UnpinTuple(rowEndIn);
			HalconAPI.UnpinTuple(colEndIn);
			HalconAPI.UnpinTuple(feature);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rowBeginOut);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out colBeginOut);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out rowEndOut);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out colEndOut);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out failRowBOut);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out failColBOut);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out failRowEOut);
			num = HTuple.LoadNew(proc, 7, HTupleType.INTEGER, num, out failColEOut);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Partition lines according to various criteria.</summary>
		/// <param name="rowBeginIn">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBeginIn">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEndIn">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEndIn">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="feature">Features to be used for selection.</param>
		/// <param name="operation">Desired combination of the features.</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: "min"</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: "max"</param>
		/// <param name="rowBeginOut">Row coordinates of the starting points of the lines fulfilling the conditions.</param>
		/// <param name="colBeginOut">Column coordinates of the starting points of the lines fulfilling the conditions.</param>
		/// <param name="rowEndOut">Row coordinates of the ending points of the lines fulfilling the conditions.</param>
		/// <param name="colEndOut">Column coordinates of the ending points of the lines fulfilling the conditions.</param>
		/// <param name="failRowBOut">Row coordinates of the starting points of the lines not fulfilling the conditions.</param>
		/// <param name="failColBOut">Column coordinates of the starting points of the lines not fulfilling the conditions.</param>
		/// <param name="failRowEOut">Row coordinates of the ending points of the lines not fulfilling the conditions.</param>
		/// <param name="failColEOut">Column coordinates of the ending points of the lines not fulfilling the conditions.</param>
		// Token: 0x06000AB3 RID: 2739 RVA: 0x00043EF4 File Offset: 0x000420F4
		public static void PartitionLines(HTuple rowBeginIn, HTuple colBeginIn, HTuple rowEndIn, HTuple colEndIn, string feature, string operation, string min, string max, out HTuple rowBeginOut, out HTuple colBeginOut, out HTuple rowEndOut, out HTuple colEndOut, out HTuple failRowBOut, out HTuple failColBOut, out HTuple failRowEOut, out HTuple failColEOut)
		{
			IntPtr proc = HalconAPI.PreCall(1737);
			HalconAPI.Store(proc, 0, rowBeginIn);
			HalconAPI.Store(proc, 1, colBeginIn);
			HalconAPI.Store(proc, 2, rowEndIn);
			HalconAPI.Store(proc, 3, colEndIn);
			HalconAPI.StoreS(proc, 4, feature);
			HalconAPI.StoreS(proc, 5, operation);
			HalconAPI.StoreS(proc, 6, min);
			HalconAPI.StoreS(proc, 7, max);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBeginIn);
			HalconAPI.UnpinTuple(colBeginIn);
			HalconAPI.UnpinTuple(rowEndIn);
			HalconAPI.UnpinTuple(colEndIn);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rowBeginOut);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out colBeginOut);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out rowEndOut);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out colEndOut);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out failRowBOut);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out failColBOut);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out failRowEOut);
			num = HTuple.LoadNew(proc, 7, HTupleType.INTEGER, num, out failColEOut);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Select lines according to various criteria.</summary>
		/// <param name="rowBeginIn">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBeginIn">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEndIn">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEndIn">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="feature">Features to be used for selection. Default: "length"</param>
		/// <param name="operation">Desired combination of the features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: "min"</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: "max"</param>
		/// <param name="rowBeginOut">Row coordinates of the starting points of the output lines.</param>
		/// <param name="colBeginOut">Column coordinates of the starting points of the output lines.</param>
		/// <param name="rowEndOut">Row coordinates of the ending points of the output lines.</param>
		/// <param name="colEndOut">Column coordinates of the ending points of the output lines.</param>
		// Token: 0x06000AB4 RID: 2740 RVA: 0x00044014 File Offset: 0x00042214
		public static void SelectLines(HTuple rowBeginIn, HTuple colBeginIn, HTuple rowEndIn, HTuple colEndIn, HTuple feature, string operation, HTuple min, HTuple max, out HTuple rowBeginOut, out HTuple colBeginOut, out HTuple rowEndOut, out HTuple colEndOut)
		{
			IntPtr proc = HalconAPI.PreCall(1738);
			HalconAPI.Store(proc, 0, rowBeginIn);
			HalconAPI.Store(proc, 1, colBeginIn);
			HalconAPI.Store(proc, 2, rowEndIn);
			HalconAPI.Store(proc, 3, colEndIn);
			HalconAPI.Store(proc, 4, feature);
			HalconAPI.StoreS(proc, 5, operation);
			HalconAPI.Store(proc, 6, min);
			HalconAPI.Store(proc, 7, max);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBeginIn);
			HalconAPI.UnpinTuple(colBeginIn);
			HalconAPI.UnpinTuple(rowEndIn);
			HalconAPI.UnpinTuple(colEndIn);
			HalconAPI.UnpinTuple(feature);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rowBeginOut);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out colBeginOut);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out rowEndOut);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out colEndOut);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Select lines according to various criteria.</summary>
		/// <param name="rowBeginIn">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBeginIn">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEndIn">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEndIn">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="feature">Features to be used for selection. Default: "length"</param>
		/// <param name="operation">Desired combination of the features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: "min"</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: "max"</param>
		/// <param name="rowBeginOut">Row coordinates of the starting points of the output lines.</param>
		/// <param name="colBeginOut">Column coordinates of the starting points of the output lines.</param>
		/// <param name="rowEndOut">Row coordinates of the ending points of the output lines.</param>
		/// <param name="colEndOut">Column coordinates of the ending points of the output lines.</param>
		// Token: 0x06000AB5 RID: 2741 RVA: 0x000440FC File Offset: 0x000422FC
		public static void SelectLines(HTuple rowBeginIn, HTuple colBeginIn, HTuple rowEndIn, HTuple colEndIn, string feature, string operation, string min, string max, out HTuple rowBeginOut, out HTuple colBeginOut, out HTuple rowEndOut, out HTuple colEndOut)
		{
			IntPtr proc = HalconAPI.PreCall(1738);
			HalconAPI.Store(proc, 0, rowBeginIn);
			HalconAPI.Store(proc, 1, colBeginIn);
			HalconAPI.Store(proc, 2, rowEndIn);
			HalconAPI.Store(proc, 3, colEndIn);
			HalconAPI.StoreS(proc, 4, feature);
			HalconAPI.StoreS(proc, 5, operation);
			HalconAPI.StoreS(proc, 6, min);
			HalconAPI.StoreS(proc, 7, max);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBeginIn);
			HalconAPI.UnpinTuple(colBeginIn);
			HalconAPI.UnpinTuple(rowEndIn);
			HalconAPI.UnpinTuple(colEndIn);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out rowBeginOut);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out colBeginOut);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out rowEndOut);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out colEndOut);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the center of gravity, length, and orientation of a line.</summary>
		/// <param name="rowBegin">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBegin">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEnd">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEnd">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="rowCenter">Row coordinates of the centers of gravity of the input lines.</param>
		/// <param name="colCenter">Column coordinates of the centers of gravity of the input lines.</param>
		/// <param name="length">Euclidean length of the input lines.</param>
		/// <param name="phi">Orientation of the input lines.</param>
		// Token: 0x06000AB6 RID: 2742 RVA: 0x000441CC File Offset: 0x000423CC
		public static void LinePosition(HTuple rowBegin, HTuple colBegin, HTuple rowEnd, HTuple colEnd, out HTuple rowCenter, out HTuple colCenter, out HTuple length, out HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(1739);
			HalconAPI.Store(proc, 0, rowBegin);
			HalconAPI.Store(proc, 1, colBegin);
			HalconAPI.Store(proc, 2, rowEnd);
			HalconAPI.Store(proc, 3, colEnd);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBegin);
			HalconAPI.UnpinTuple(colBegin);
			HalconAPI.UnpinTuple(rowEnd);
			HalconAPI.UnpinTuple(colEnd);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowCenter);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out colCenter);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out length);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out phi);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the center of gravity, length, and orientation of a line.</summary>
		/// <param name="rowBegin">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBegin">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEnd">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEnd">Column coordinates  of the ending points of the input lines.</param>
		/// <param name="rowCenter">Row coordinates of the centers of gravity of the input lines.</param>
		/// <param name="colCenter">Column coordinates of the centers of gravity of the input lines.</param>
		/// <param name="length">Euclidean length of the input lines.</param>
		/// <param name="phi">Orientation of the input lines.</param>
		// Token: 0x06000AB7 RID: 2743 RVA: 0x00044278 File Offset: 0x00042478
		public static void LinePosition(double rowBegin, double colBegin, double rowEnd, double colEnd, out double rowCenter, out double colCenter, out double length, out double phi)
		{
			IntPtr proc = HalconAPI.PreCall(1739);
			HalconAPI.StoreD(proc, 0, rowBegin);
			HalconAPI.StoreD(proc, 1, colBegin);
			HalconAPI.StoreD(proc, 2, rowEnd);
			HalconAPI.StoreD(proc, 3, colEnd);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out rowCenter);
			num = HalconAPI.LoadD(proc, 1, num, out colCenter);
			num = HalconAPI.LoadD(proc, 2, num, out length);
			num = HalconAPI.LoadD(proc, 3, num, out phi);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Calculate the orientation of lines.</summary>
		/// <param name="rowBegin">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBegin">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEnd">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEnd">Column coordinates  of the ending points of the input lines.</param>
		/// <returns>Orientation of the input lines.</returns>
		// Token: 0x06000AB8 RID: 2744 RVA: 0x00044308 File Offset: 0x00042508
		public static HTuple LineOrientation(HTuple rowBegin, HTuple colBegin, HTuple rowEnd, HTuple colEnd)
		{
			IntPtr proc = HalconAPI.PreCall(1740);
			HalconAPI.Store(proc, 0, rowBegin);
			HalconAPI.Store(proc, 1, colBegin);
			HalconAPI.Store(proc, 2, rowEnd);
			HalconAPI.Store(proc, 3, colEnd);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBegin);
			HalconAPI.UnpinTuple(colBegin);
			HalconAPI.UnpinTuple(rowEnd);
			HalconAPI.UnpinTuple(colEnd);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Calculate the orientation of lines.</summary>
		/// <param name="rowBegin">Row coordinates of the starting points of the input lines.</param>
		/// <param name="colBegin">Column coordinates of the starting points of the input lines.</param>
		/// <param name="rowEnd">Row coordinates of the ending points of the input lines.</param>
		/// <param name="colEnd">Column coordinates  of the ending points of the input lines.</param>
		/// <returns>Orientation of the input lines.</returns>
		// Token: 0x06000AB9 RID: 2745 RVA: 0x0004437C File Offset: 0x0004257C
		public static double LineOrientation(double rowBegin, double colBegin, double rowEnd, double colEnd)
		{
			IntPtr proc = HalconAPI.PreCall(1740);
			HalconAPI.StoreD(proc, 0, rowBegin);
			HalconAPI.StoreD(proc, 1, colBegin);
			HalconAPI.StoreD(proc, 2, rowEnd);
			HalconAPI.StoreD(proc, 3, colEnd);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Approximate a contour by arcs and lines.</summary>
		/// <param name="row">Row of the contour. Default: 32</param>
		/// <param name="column">Column of the contour. Default: 32</param>
		/// <param name="arcCenterRow">Row of the center of an arc.</param>
		/// <param name="arcCenterCol">Column of the center of an arc.</param>
		/// <param name="arcAngle">Angle of an arc.</param>
		/// <param name="arcBeginRow">Row of the starting point of an arc.</param>
		/// <param name="arcBeginCol">Column of the starting point of an arc.</param>
		/// <param name="lineBeginRow">Row of the starting point of a line segment.</param>
		/// <param name="lineBeginCol">Column of the starting point of a line segment.</param>
		/// <param name="lineEndRow">Row of the ending point of a line segment.</param>
		/// <param name="lineEndCol">Column of the ending point of a line segment.</param>
		/// <param name="order">Sequence of line (value 0) and arc segments (value 1).</param>
		// Token: 0x06000ABA RID: 2746 RVA: 0x000443D4 File Offset: 0x000425D4
		public static void ApproxChainSimple(HTuple row, HTuple column, out HTuple arcCenterRow, out HTuple arcCenterCol, out HTuple arcAngle, out HTuple arcBeginRow, out HTuple arcBeginCol, out HTuple lineBeginRow, out HTuple lineBeginCol, out HTuple lineEndRow, out HTuple lineEndCol, out HTuple order)
		{
			IntPtr proc = HalconAPI.PreCall(1741);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out arcCenterRow);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out arcCenterCol);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out arcAngle);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out arcBeginRow);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out arcBeginCol);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out lineBeginRow);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out lineBeginCol);
			num = HTuple.LoadNew(proc, 7, HTupleType.INTEGER, num, out lineEndRow);
			num = HTuple.LoadNew(proc, 8, HTupleType.INTEGER, num, out lineEndCol);
			num = HTuple.LoadNew(proc, 9, HTupleType.INTEGER, num, out order);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>Approximate a contour by arcs and lines.</summary>
		/// <param name="row">Row of the contour. Default: 32</param>
		/// <param name="column">Column of the contour. Default: 32</param>
		/// <param name="minWidthCoord">Minimum width of Gauss operator for coordinate smoothing ($ greater than $ 0.4). Default: 0.5</param>
		/// <param name="maxWidthCoord">Maximum width of Gauss operator for coordinate smoothing ($ greater than $ 0.4). Default: 2.4</param>
		/// <param name="threshStart">Minimum threshold value of the curvature for accepting a corner (relative to the largest curvature present). Default: 0.3</param>
		/// <param name="threshEnd">Maximum threshold value of the curvature for accepting a corner (relative to the largest curvature present). Default: 0.9</param>
		/// <param name="threshStep">Step width for threshold increase. Default: 0.2</param>
		/// <param name="minWidthSmooth">Minimum width of Gauss operator for smoothing the curvature function ($ greater than $ 0.4). Default: 0.5</param>
		/// <param name="maxWidthSmooth">Maximum width of Gauss operator for smoothing the curvature function. Default: 2.4</param>
		/// <param name="minWidthCurve">Minimum width of curve area for curvature determination ($ greater than $ 0.4). Default: 2</param>
		/// <param name="maxWidthCurve">Maximum width of curve area for curvature determination. Default: 12</param>
		/// <param name="weight1">Weighting factor for approximation precision. Default: 1.0</param>
		/// <param name="weight2">Weighting factor for large segments. Default: 1.0</param>
		/// <param name="weight3">Weighting factor for small segments. Default: 1.0</param>
		/// <param name="arcCenterRow">Row of the center of an arc.</param>
		/// <param name="arcCenterCol">Column of the center of an arc.</param>
		/// <param name="arcAngle">Angle of an arc.</param>
		/// <param name="arcBeginRow">Row of the starting point of an arc.</param>
		/// <param name="arcBeginCol">Column of the starting point of an arc.</param>
		/// <param name="lineBeginRow">Row of the starting point of a line segment.</param>
		/// <param name="lineBeginCol">Column of the starting point of a line segment.</param>
		/// <param name="lineEndRow">Row of the ending point of a line segment.</param>
		/// <param name="lineEndCol">Column of the ending point of a line segment.</param>
		/// <param name="order">Sequence of line (value 0) and arc segments (value 1).</param>
		// Token: 0x06000ABB RID: 2747 RVA: 0x000444DC File Offset: 0x000426DC
		public static void ApproxChain(HTuple row, HTuple column, double minWidthCoord, double maxWidthCoord, double threshStart, double threshEnd, double threshStep, double minWidthSmooth, double maxWidthSmooth, int minWidthCurve, int maxWidthCurve, double weight1, double weight2, double weight3, out HTuple arcCenterRow, out HTuple arcCenterCol, out HTuple arcAngle, out HTuple arcBeginRow, out HTuple arcBeginCol, out HTuple lineBeginRow, out HTuple lineBeginCol, out HTuple lineEndRow, out HTuple lineEndCol, out HTuple order)
		{
			IntPtr proc = HalconAPI.PreCall(1742);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, minWidthCoord);
			HalconAPI.StoreD(proc, 3, maxWidthCoord);
			HalconAPI.StoreD(proc, 4, threshStart);
			HalconAPI.StoreD(proc, 5, threshEnd);
			HalconAPI.StoreD(proc, 6, threshStep);
			HalconAPI.StoreD(proc, 7, minWidthSmooth);
			HalconAPI.StoreD(proc, 8, maxWidthSmooth);
			HalconAPI.StoreI(proc, 9, minWidthCurve);
			HalconAPI.StoreI(proc, 10, maxWidthCurve);
			HalconAPI.StoreD(proc, 11, weight1);
			HalconAPI.StoreD(proc, 12, weight2);
			HalconAPI.StoreD(proc, 13, weight3);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out arcCenterRow);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out arcCenterCol);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out arcAngle);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out arcBeginRow);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out arcBeginCol);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out lineBeginRow);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out lineBeginCol);
			num = HTuple.LoadNew(proc, 7, HTupleType.INTEGER, num, out lineEndRow);
			num = HTuple.LoadNew(proc, 8, HTupleType.INTEGER, num, out lineEndCol);
			num = HTuple.LoadNew(proc, 9, HTupleType.INTEGER, num, out order);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>This operator is inoperable. It had the following function:  Destroy all classifiers.</summary>
		// Token: 0x06000ABC RID: 2748 RVA: 0x00044658 File Offset: 0x00042858
		public static void CloseAllClassBox()
		{
			IntPtr proc = HalconAPI.PreCall(1900);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Generate a calibration plate description file and a corresponding PostScript file for a calibration plate with rectangularly arranged marks.</summary>
		/// <param name="XNum">Number of marks in x direction. Default: 7</param>
		/// <param name="YNum">Number of marks in y direction. Default: 7</param>
		/// <param name="markDist">Distance of the marks in meters. Default: 0.0125</param>
		/// <param name="diameterRatio">Ratio of the mark diameter to the mark distance. Default: 0.5</param>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "caltab.descr"</param>
		/// <param name="calPlatePSFile">File name of the PostScript file. Default: "caltab.ps"</param>
		// Token: 0x06000ABD RID: 2749 RVA: 0x0004467C File Offset: 0x0004287C
		public static void GenCaltab(int XNum, int YNum, double markDist, double diameterRatio, string calPlateDescr, string calPlatePSFile)
		{
			IntPtr proc = HalconAPI.PreCall(1926);
			HalconAPI.StoreI(proc, 0, XNum);
			HalconAPI.StoreI(proc, 1, YNum);
			HalconAPI.StoreD(proc, 2, markDist);
			HalconAPI.StoreD(proc, 3, diameterRatio);
			HalconAPI.StoreS(proc, 4, calPlateDescr);
			HalconAPI.StoreS(proc, 5, calPlatePSFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Generate a calibration plate description file and a corresponding PostScript file for a calibration plate with hexagonally arranged marks.</summary>
		/// <param name="numRows">Number of rows. Default: 27</param>
		/// <param name="marksPerRow">Number of marks per row. Default: 31</param>
		/// <param name="diameter">Diameter of the marks. Default: 0.00258065</param>
		/// <param name="finderRow">Row indices of the finder patterns. Default: [13,6,6,20,20]</param>
		/// <param name="finderColumn">Column indices of the finder patterns. Default: [15,6,24,6,24]</param>
		/// <param name="polarity">Polarity of the marks Default: "light_on_dark"</param>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "calplate.cpd"</param>
		/// <param name="calPlatePSFile">File name of the PostScript file. Default: "calplate.ps"</param>
		// Token: 0x06000ABE RID: 2750 RVA: 0x000446D4 File Offset: 0x000428D4
		public static void CreateCaltab(int numRows, int marksPerRow, double diameter, HTuple finderRow, HTuple finderColumn, string polarity, string calPlateDescr, string calPlatePSFile)
		{
			IntPtr proc = HalconAPI.PreCall(1927);
			HalconAPI.StoreI(proc, 0, numRows);
			HalconAPI.StoreI(proc, 1, marksPerRow);
			HalconAPI.StoreD(proc, 2, diameter);
			HalconAPI.Store(proc, 3, finderRow);
			HalconAPI.Store(proc, 4, finderColumn);
			HalconAPI.StoreS(proc, 5, polarity);
			HalconAPI.StoreS(proc, 6, calPlateDescr);
			HalconAPI.StoreS(proc, 7, calPlatePSFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(finderRow);
			HalconAPI.UnpinTuple(finderColumn);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Generate a calibration plate description file and a corresponding PostScript file for a calibration plate with hexagonally arranged marks.</summary>
		/// <param name="numRows">Number of rows. Default: 27</param>
		/// <param name="marksPerRow">Number of marks per row. Default: 31</param>
		/// <param name="diameter">Diameter of the marks. Default: 0.00258065</param>
		/// <param name="finderRow">Row indices of the finder patterns. Default: [13,6,6,20,20]</param>
		/// <param name="finderColumn">Column indices of the finder patterns. Default: [15,6,24,6,24]</param>
		/// <param name="polarity">Polarity of the marks Default: "light_on_dark"</param>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "calplate.cpd"</param>
		/// <param name="calPlatePSFile">File name of the PostScript file. Default: "calplate.ps"</param>
		// Token: 0x06000ABF RID: 2751 RVA: 0x0004474C File Offset: 0x0004294C
		public static void CreateCaltab(int numRows, int marksPerRow, double diameter, int finderRow, int finderColumn, string polarity, string calPlateDescr, string calPlatePSFile)
		{
			IntPtr proc = HalconAPI.PreCall(1927);
			HalconAPI.StoreI(proc, 0, numRows);
			HalconAPI.StoreI(proc, 1, marksPerRow);
			HalconAPI.StoreD(proc, 2, diameter);
			HalconAPI.StoreI(proc, 3, finderRow);
			HalconAPI.StoreI(proc, 4, finderColumn);
			HalconAPI.StoreS(proc, 5, polarity);
			HalconAPI.StoreS(proc, 6, calPlateDescr);
			HalconAPI.StoreS(proc, 7, calPlatePSFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Read the mark center points from the calibration plate description file.</summary>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "calplate_320mm.cpd"</param>
		/// <param name="x">X coordinates of the mark center points in the coordinate system of the calibration plate.</param>
		/// <param name="y">Y coordinates of the mark center points in the coordinate system of the calibration plate.</param>
		/// <param name="z">Z coordinates of the mark center points in the coordinate system of the calibration plate.</param>
		// Token: 0x06000AC0 RID: 2752 RVA: 0x000447B4 File Offset: 0x000429B4
		public static void CaltabPoints(string calPlateDescr, out HTuple x, out HTuple y, out HTuple z)
		{
			IntPtr proc = HalconAPI.PreCall(1928);
			HalconAPI.StoreS(proc, 0, calPlateDescr);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out z);
			HalconAPI.PostCall(proc, num);
		}

		/// <summary>This operator is inoperable. It had the following function:  Delete all background estimation data sets.</summary>
		// Token: 0x06000AC1 RID: 2753 RVA: 0x0004481C File Offset: 0x00042A1C
		public static void CloseAllBgEsti()
		{
			IntPtr proc = HalconAPI.PreCall(2009);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>This operator is inoperable. It had the following function:  Close all image acquisition devices.</summary>
		// Token: 0x06000AC2 RID: 2754 RVA: 0x00044840 File Offset: 0x00042A40
		public static void CloseAllFramegrabbers()
		{
			IntPtr proc = HalconAPI.PreCall(2035);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}
	}
}
